package com.niit.scala

import scala.collection.mutable.{ArrayBuffer, ListBuffer}

/**
 * Date:2025/3/24
 * Author：Ys
 * Description:
 */
object Base07 {

  /*
   数组 、元组  列表
   */

  def main(args: Array[String]): Unit = {

   /*
   1.数组
     1.1 定长数组
     1.2 变长数组
     1.3 数组的修改
     1.4 数组的遍历
    */
    //1.1 定长数组：长度不允许改变 格式：var/val 变量名= new Array[数据类型](长度)
    var arr1 = new Array[Int](10) //数据类型为整型 长度为10
    var arr2 = Array(10,20,30,40,50)
    println(arr2( 2 )) //
    println(arr1( 9 )) // 最大索引值 = 长度 - 1
    //println(arr2( 8 )) // ArrayIndexOutOfBoundsException 索引值越界  第一检查序列是否为空，第二检查序列的长度

    //1.2 变长数组：长度可以改变 格式：var/val 变量名= ArrayBuffer[数据类型]()
    val ab1: ArrayBuffer[Int] = ArrayBuffer[Int]()
    val ab2: ArrayBuffer[String] = ArrayBuffer("Java", "JavaScript", "Python", "Scala", "C", "MySQL", "Hadoop", "HBase", "HTML-CSS")

    //变长数组的修改  增 删
    //追加一个元素
    ab2 += "Spark"
    println(ab2)
    //追加多个元素
    ab2 ++= Array("Kafak", "Flume")
    println(ab2)
    //删除
    ab2 -= "HTML-CSS"
    ab2 --= Array("C", "Python")
    println(ab2)
    ab2(1) = "DataView"
    println(ab2)

    //数组的遍历
    //方式一 ：根据长度进行遍历，根据索引值进行输出  to 闭区间
    for (i <- 0 to ab2.length -1){
       println(ab2(i))
    }

    //方式二： 根据长度进行遍历，根据索引值进行输出  until 左闭右开的区间
    for (i <- 0 until ab2.length){
      println(ab2(i))
    }
    //方式三
    for (i <- ab2){
      //i 就是数组中的每一个元素
      println(i)
    }

    //2.元组 ： 元组中的元素个数固定，并且类型可以不同，长度和元素都不可以改变
    //2.1 元组的定义
    //2.2 访问元组中的元素
    //定义元组
    var tuple1 = ("张三",23,'男')
    println(tuple1)

    //访问元组中的元素  不是用索引值，而是用的序号
    println(tuple1._1)

    //元组的遍历，先用元组去生成一个迭代器，去遍历迭代器
    val it: Iterator[Any] = tuple1.productIterator
    for(i <- it){
      println(i)
    }

   /*
   3.列表  特点：有序 可重复
     3.1 不可变列表
     3.2 可变列表
     3.3 列表的扁平化
     3.4 列表的拉链与拉开
     3.5 列表的交并差集
    */
   //不可变列表  元素和长度都是不可以改变的
   var list1 = List(3,4,1,4,2,3)
   var list2 = Nil // 创建一个不可变的空列表  var list2 = List()
   var list3= 2 :: 1 :: Nil // 了解 使用双冒号形式创建列表 里面只包含了 2 和 1
   println(list1,list2,list3)

   //可变列表
   var lb1 = ListBuffer[Int]()
   var lb2= ListBuffer(1,2,3,4,5)

   lb1 += 10
   lb1 += 30
   lb1 ++= List(10,3,100)
   println(lb1)

   //列表转换 可变列表 转换 不可变列表  可变列表转换数组
   val list4: List[Int] = lb1.toList
   val arr3: Array[Int] = lb1.toArray

   //去重 distinct
   val distinct: ListBuffer[Int] = lb1.distinct
   println(distinct)

   //head 获得列表中的首个元素
   println(lb1.head)
   //tail 获得列表中的除首个元素外的其他元素
   println(lb1.tail)

   //take: 获取列表中前n个元素 drop: 获取列表中除前n个元素外的其他元素
   val value = lb1.take(3)
   val value1 = lb1.drop(3)
   println(value,value1)

   //列表的扁平化，将嵌套的列表，变成一个列表
   var list5 = List( List(1,2),List(3,4),List(5) )
   val list6: List[Int] = list5.flatten
   println(list6)

   //列表的拉链，将两个列表，组成 元素为元组的列表
   val names = List("张三","李四","王五")
   val ages = List(23,24,25)
   val list7: List[(String, Int)] = names.zip(ages)
   println(list7)//ist((张三,23), (李四,24), (王五,25))

   //拉开： 将一个包含元素的列表，拆解成两个列表的元组
   val tu: (List[String], List[Int]) = list7.unzip
   println(tu)

   //列表的交并差集
   val list8 = List(1,2,3,4)
   val list9 = List(3,4,5,6)

   //并集
   val value2: List[Int] = list8.union(list9)
   println(value2)

   //交集
   val value3: List[Int] = list8.intersect(list9)
   println(value3)

   //差集
   val value4: List[Int] = list8.diff(list9)
   println(value4)
  }

}
